#include "inherit.h"

template <class T>
void func(T)
{
    cout<<"void func(class T)";
}

class ParentA{
    public:
    ParentA(int a = 10)
    {
        cout<<"ParentA"<<endl;
    }
    ParentA(const ParentA& pa)
    {
        cout<<"ParentA(const ParentA& pa)"<<endl;
    }
    ParentA operator=(const ParentA& pa)
    {
        cout<<"ParentA operator="<<endl;
        a = pa.a;
        //假设完成拷贝
        return *this;
    }
    void func()
    {

    }
    ~ParentA(){
        cout<<"~ParentA"<<endl;
    }
    int a;
    private:
    int A_b;
    // static int count;

    protected:
    // static int count;//静态成员变量属于整个类，子类不谈继承一说，子类也可以正常访问,但是需要protect或者是公有

    int c;
};
class B:public ParentA
{
    public:
    B()
    :ParentA(10)        //类的构造函数里面，应该实现父类会自动调用初始化，如果需要显示调用就要如此写（编译器自动生成的也会如此做
                        //例如父类构造函数不是没有全缺省和无参数构造函数，就必须要显示调用
                        //且父类构造函数总是在之前调用
    {
        cout<<"B"<<endl;
    }
    B& operator=(const B& b)//编译器自动生成的也会去调用父类的赋值重载
    {
        if(this==&b)
        {
            return *this;
        }
        this->ParentA::operator=(b);//这里要主动去调用父类的赋值重载，所以在赋值时，需要调用父类的赋值重载才行
        //已经做深拷贝
        cout<<"B& operator=(const B& b)"<<endl;
        return *this; 
    }
    B(const B& b)
     //:ParentA(b)//拷贝构造如果自己不调用，就调用父类的默认构造函数
    {
        cout<<"B(const B& b)";
    }

    void func()//父类里面也用相同的函数成员，子类依旧可以有同名的，但是之间的关系构成隐藏
    {

    }
    void func(int a)//值得注意的是，这个函数依然和父类的func函数是构成的隐藏，而并非所谓重载。根本原因就是不在一个作用域
    {

    }

    //由于多态的原因，析构函数“都”会形成destuctor
    //所以父子类析构函数构成隐藏关系，这个析构函数想显示调用就必须要加上父亲的类域

    ~B(){
        //析构函数调用时，会优先调用子类的析构
        //ParentA::~ParentA();但是子类会自动调动父亲构造函数，所以就不需要在调用，否则容易出现问题
    }
    int b;
};

void test_1()
{
    B b;
    b.a = 10;
    B c(b);
    b.a = 20;
    // c.a=10;
    c = b;
    ParentA & pa = b;//这里是切割，引用的还是b的地址，仅仅指向子类从父亲继承那一部分。
    cout<<&pa<<'\n'<<&b;
    
}





//多继承
class PA
{
    public:
    PA()
    {
        cout<<"PA"<<endl;
    }
    protected:
    void func(){}
    int m_pa;
};

class CB: PA
{
    public: CB()
    {

    }
    protected:
    int m_cb;
    void fun(){}
    double m_pa;
};

class CC:PA
{
    protected:
    int m_cc;
};

class CD:CB,CC
{
    protected:
    int m_cd;
    double m_pa;
};







// //test 
// int main()
// {
//     test_1();
//     return 0;
// }